home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Src / MTAconsole / create.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  54.4 KB  |  2,031 lines
  1. /* create.c: creation for all X widgets */
  2. # ifndef lint
  3. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Src/MTAconsole/RCS/create.c,v 6.0 1991/12/18 20:26:48 jpo Rel $";
  4. # endif
  5.  
  6. /*
  7.  * $Header: /xtel/pp/pp-beta/Src/MTAconsole/RCS/create.c,v 6.0 1991/12/18 20:26:48 jpo Rel $
  8.  *
  9.  * $Log: create.c,v $
  10.  * Revision 6.0  1991/12/18  20:26:48  jpo
  11.  * Release 6.0
  12.  *
  13.  */
  14.  
  15.  
  16.  
  17. #include    "console.h"
  18.  
  19. #define    TOTAL_WIDTH    600
  20. #define VP_HEIGHT    120
  21.  
  22. static void create_commandwidgets();
  23. static void create_channelwidgets();
  24. static void create_mtawidgets();
  25. static void create_msgwidgets();
  26. static void create_controlwidgets();
  27. static void create_monitorwidgets();
  28. static void create_popupwidgets();
  29. extern char    *myname;
  30. Widget        top,
  31.         mainform,
  32.         topform,
  33.         nextform,
  34.         mainvpane,
  35.         channel_form,
  36.         mta_form,
  37.         msg_form,
  38.         switchform,
  39.         header = NULL,
  40.         error = NULL,
  41.         statistics = NULL,
  42.         monitor_viewport,
  43.         control_form;
  44. int        errorUp = 0;
  45.  
  46. extern char    *ppversion;
  47. extern void client_msg_handler();
  48. extern XFontStruct    *normalFont;
  49. int        strlen_msgall;
  50.  
  51. Arg    argList[10];
  52.  
  53. /* ARGSUSED */
  54. create_widgets(display, context)
  55. Display        *display;
  56. XtAppContext    context;
  57. {
  58.     Dimension    ht;
  59.  
  60.     XtSetArg(argList[0], XtNfont, normalFont);
  61.  
  62.     XtAddEventHandler(top, NoEventMask, TRUE, client_msg_handler, NULL);
  63.     
  64.     mainform = XtVaCreateManagedWidget("mainform",
  65.                 formWidgetClass,
  66.                 top,
  67.                 NULL);
  68.  
  69.     mainvpane = XtVaCreateManagedWidget("mainvpane",
  70.                  panedWidgetClass,
  71.                  mainform,
  72.                  NULL);
  73.                  
  74.     create_commandwidgets();
  75.     create_channelwidgets();
  76.  
  77.     switchform = XtVaCreateManagedWidget("switchForm",
  78.                   formWidgetClass,
  79.                   mainvpane,
  80.                   NULL);
  81.     create_controlwidgets();
  82.     create_popupwidgets(context);
  83.     XtRealizeWidget(top);
  84.     XtVaGetValues(topform,
  85.           XtNheight,    &ht,
  86.           NULL);
  87.     XtVaSetValues(topform,
  88.           XtNmin,    ht,
  89.           XtNmax,    ht,
  90.           NULL);
  91.     XtVaGetValues(nextform,
  92.           XtNheight,    &ht,
  93.           NULL);
  94.     XtVaSetValues(nextform,
  95.           XtNmin,    ht,
  96.           XtNmax,    ht,
  97.           NULL);
  98.     XtVaGetValues(channel_form,
  99.           XtNheight,    &ht,
  100.           NULL);
  101.     XtVaSetValues(channel_form,
  102.           XtNmin,    ht,
  103.           XtNmax,    ht,
  104.           NULL);
  105.     XtVaGetValues(mta_form,
  106.           XtNheight,    &ht,
  107.           NULL);
  108.     XtVaSetValues(mta_form,
  109.           XtNmin,    ht,
  110.           XtNmax,    ht,
  111.           NULL);
  112.     XtVaGetValues(msg_form,
  113.           XtNheight,    &ht,
  114.           NULL);
  115.     XtVaSetValues(msg_form,
  116.           XtNmin,    ht,
  117.           XtNmax,    ht,
  118.           NULL);
  119.     create_monitorwidgets();
  120.     XtInstallAllAccelerators(mainform, mainform);
  121.     MapButtons(False); /* can't see before connect */
  122.     MapVolume(False);
  123. }
  124.  
  125. Widget        quit_command,
  126.         connect_command,
  127.         refresh_command,
  128.         mode_command,
  129.         config_command,
  130.         qcontrol_command,
  131.         total_volume_label,
  132.         total_number_label,
  133.           time_label,
  134.         runChans_label, qOps_label, msgInPs_label, msgOutPs_label,
  135.         runChans_sc, qOps_sc, msgInPs_sc, msgOutPs_sc,
  136.         compat_stat_pane;
  137.  
  138. extern void Refresh(),
  139.         Command(),
  140.         Connectbutton(),
  141.         Configure(),
  142.         QControlPopup(),
  143.         ChangeMode(),
  144.         setLoad();
  145. extern double    runnableChans, opsPerSec, msgsInPerSec, msgsOutPerSec;
  146.  
  147. extern XFontStruct    *normalFont;
  148. extern unsigned long    timeoutFor;
  149. extern int        compat;
  150.  
  151. static void create_commandwidgets()
  152. {
  153.     Widget    pane, form, mainpane;
  154.  
  155.     topform = XtVaCreateManagedWidget("generalCommands",
  156.                    formWidgetClass,
  157.                    mainvpane,
  158.                    NULL);
  159.  
  160.     refresh_command = XtVaCreateManagedWidget("refreshCommand",
  161.                        commandWidgetClass,
  162.                        topform,
  163.                        XtNlabel,    "refresh",
  164.                        NULL);
  165.     if (normalFont != NULL)
  166.         XtSetValues(refresh_command, argList, 1);
  167.  
  168.     XtAddCallback(refresh_command, XtNcallback, Refresh, NULL);
  169.  
  170.     quit_command = XtVaCreateManagedWidget("quitCommand",
  171.                     commandWidgetClass,
  172.                     topform,
  173.                     XtNlabel,        "quit",
  174.                     NULL);
  175.     XtAddCallback(quit_command, XtNcallback, Command, quit);
  176.     if (normalFont != NULL)
  177.         XtSetValues(quit_command, argList, 1);
  178.  
  179.     connect_command = XtVaCreateManagedWidget("connectCommand",
  180.                        commandWidgetClass,
  181.                        topform,
  182.                        XtNlabel, "connect",
  183.                        NULL);
  184.     XtAddCallback(connect_command, XtNcallback, Connectbutton, connect); 
  185.     if (normalFont != NULL)
  186.         XtSetValues(connect_command,argList, 1);
  187.  
  188.     mode_command = XtVaCreateManagedWidget("modeCommand",
  189.                     commandWidgetClass,
  190.                     topform,
  191.                     XtNlabel, "control",
  192.                     NULL);
  193.     XtAddCallback(mode_command, XtNcallback, ChangeMode, NULL);
  194.     if (normalFont != NULL)
  195.         XtSetValues(mode_command,argList, 1);
  196.  
  197.     config_command = XtVaCreateManagedWidget("configCommand",
  198.                       commandWidgetClass,
  199.                       topform,
  200.                       XtNlabel, "configuration",
  201.                       NULL);
  202.     XtAddCallback(config_command, XtNcallback, Configure, NULL);
  203.     if (normalFont != NULL)
  204.         XtSetValues(config_command,argList, 1);
  205.  
  206.     qcontrol_command = XtVaCreateManagedWidget("qcontrolCommand",
  207.                     commandWidgetClass,
  208.                     topform,
  209.                     XtNlabel, "Qmgr control",
  210.                     NULL);
  211.     XtAddCallback(qcontrol_command, XtNcallback, QControlPopup, NULL);
  212.     if (normalFont != NULL)
  213.         XtSetValues(qcontrol_command,argList, 1);
  214.  
  215.     nextform = XtVaCreateManagedWidget("statusForm",
  216.                    formWidgetClass,
  217.                    mainvpane,
  218.                    NULL);
  219.  
  220.     mainpane = XtVaCreateManagedWidget("statusMainPane",
  221.                 panedWidgetClass,
  222.                 nextform,
  223.                 NULL);
  224.     pane = XtVaCreateManagedWidget("statusPane",
  225.                 panedWidgetClass,
  226.                 mainpane,
  227.                 NULL);
  228.     form = XtVaCreateManagedWidget("statusForm1",
  229.                 formWidgetClass,
  230.                 pane,
  231.                 NULL);
  232.     runChans_label = XtVaCreateManagedWidget("runChans",
  233.                    labelWidgetClass,
  234.                    form,
  235.                    NULL);
  236.     if (normalFont != NULL)
  237.         XtSetValues(runChans_label,argList, 1);
  238.  
  239.     runChans_sc = XtVaCreateManagedWidget("runChansStripChart",
  240.                 stripChartWidgetClass,
  241.                 form,
  242.                 XtNupdate,    (int) (timeoutFor / 2000),
  243.                 NULL);
  244.     XtAddCallback(runChans_sc, XtNgetValue, setLoad, &runnableChans);
  245.  
  246.     form = XtVaCreateManagedWidget("statusForm2",
  247.                 formWidgetClass,
  248.                 pane,
  249.                 NULL);
  250.  
  251.     qOps_label = XtVaCreateManagedWidget("qOps",
  252.                    labelWidgetClass,
  253.                    form,
  254.                    NULL);
  255.     if (normalFont != NULL)
  256.         XtSetValues(qOps_label,argList, 1);
  257.  
  258.     qOps_sc = XtVaCreateManagedWidget("qOpsStripChart",
  259.                 stripChartWidgetClass,
  260.                 form,
  261.                 XtNupdate,    (int) (timeoutFor / 2000),
  262.                 NULL);
  263.     XtAddCallback(qOps_sc, XtNgetValue, setLoad, &opsPerSec);
  264.     
  265.     if (!compat) {
  266.         compat_stat_pane = pane = XtVaCreateManagedWidget("statusPane2",
  267.                                   panedWidgetClass,
  268.                                   mainpane,
  269.                                   NULL);
  270.         form = XtVaCreateManagedWidget("statusForm3",
  271.                            formWidgetClass,
  272.                            pane,
  273.                            NULL);
  274.         msgInPs_label = XtVaCreateManagedWidget("msgInPs",
  275.                             labelWidgetClass,
  276.                             form,
  277.                             NULL);
  278.         if (normalFont != NULL)
  279.             XtSetValues(msgInPs_label,argList, 1);
  280.  
  281.         msgInPs_sc = XtVaCreateManagedWidget("msgInPsStripChart",
  282.                              stripChartWidgetClass,
  283.                              form,
  284.                              XtNupdate,    (int) (timeoutFor / 2000),
  285.                              NULL);
  286.         XtAddCallback(msgInPs_sc, XtNgetValue, setLoad, &msgsInPerSec);
  287.  
  288.         form = XtVaCreateManagedWidget("statusForm4",
  289.                            formWidgetClass,
  290.                            pane,
  291.                            NULL);
  292.  
  293.         msgOutPs_label = XtVaCreateManagedWidget("msgOutPs",
  294.                              labelWidgetClass,
  295.                              form,
  296.                              NULL);
  297.         if (normalFont != NULL)
  298.             XtSetValues(msgOutPs_label,argList, 1);
  299.  
  300.         msgOutPs_sc = XtVaCreateManagedWidget("msgOutPsStripChart",
  301.                               stripChartWidgetClass,
  302.                               form,
  303.                               XtNupdate,    (int) (timeoutFor / 2000),
  304.                               NULL);
  305.         XtAddCallback(msgOutPs_sc, XtNgetValue, setLoad, &msgsOutPerSec);
  306.     }
  307.     form = XtVaCreateManagedWidget("statusFormEnd",
  308.                 formWidgetClass,
  309.                 nextform,
  310.                 NULL);
  311.     total_volume_label = XtVaCreateManagedWidget("totalVolume",
  312.                       labelWidgetClass,
  313.                       form,
  314.                       XtNlabel,    "Total volume",
  315.                       NULL);
  316.     if (normalFont != NULL)
  317.         XtSetValues(total_volume_label,argList, 1);
  318.  
  319.     total_number_label = XtVaCreateManagedWidget("totalNumber",
  320.                       labelWidgetClass,
  321.                       form,
  322.                       XtNlabel,    "Total number of messages",
  323.                       NULL);
  324.     if (normalFont != NULL)
  325.         XtSetValues(total_number_label,argList, 1);
  326.  
  327.     time_label = XtVaCreateManagedWidget("timeLabel",
  328.                   labelWidgetClass,
  329.                   form,
  330.                   XtNlabel, "qmgr status",
  331.                   NULL);
  332.     if (normalFont != NULL)
  333.         XtSetValues(time_label,argList, 1);
  334.  
  335.     header = XtVaCreateManagedWidget("headerLabel",
  336.                   labelWidgetClass,
  337.                   form,
  338.                   XtNlabel,    NO_CONNECTION,
  339.                   NULL);
  340.     if (normalFont != NULL)
  341.         XtSetValues(header,argList, 1);
  342.  
  343.  
  344.     error = XtVaCreateManagedWidget("errorLabel",
  345.                     labelWidgetClass,
  346.                     form,
  347.                     XtNlabel,    NO_CONNECTION,
  348.                     NULL);
  349.     if (normalFont != NULL)
  350.         XtSetValues(error,argList, 1);
  351.  
  352.     if (!compat) {
  353.         statistics = XtVaCreateManagedWidget("statLabel",
  354.                              labelWidgetClass,
  355.                              form,
  356.                              XtNlabel,    "Qmgr\nstatistics\n\n",
  357.                              NULL);
  358.         if (normalFont != NULL)
  359.             XtSetValues(statistics,argList, 1);
  360.         errorUp = 0;
  361.     }
  362. }
  363.  
  364.  
  365. Widget    channels,
  366.     channel_header,
  367.     channel_commands,
  368.     channel_stop,
  369.     channel_start,
  370.     channel_clear,
  371.     channel_cacheadd,
  372.     channel_downforce,
  373.     channel_label,
  374.     channel_info,
  375.     channel_next,
  376.     channel_prev,
  377.     channel_all,
  378.     channel_viewport,
  379.     channel_all_form,
  380.     channel_all_list;
  381.  
  382. extern struct chan_struct    *currentchan;
  383. extern int            max_chan_border,
  384.                 read_currentchan;
  385. char                *curlabel,
  386.                 *channel_info_str,
  387.                 *create_channel_header();
  388. int                channel_info_strlen;
  389.  
  390. static void create_channelwidgets()
  391. {
  392.     Widget    temp_form;
  393.     char    *str;
  394.  
  395.     channel_form = XtVaCreateManagedWidget("channelForm",
  396.                     formWidgetClass,
  397.                     mainvpane,
  398.                     NULL);
  399.  
  400.     channel_header = XtVaCreateManagedWidget("channelHeader",
  401.                       labelWidgetClass,
  402.                       channel_form,
  403.                       NULL);
  404.     if (normalFont != NULL)
  405.         XtSetValues(channel_header,argList, 1);
  406.  
  407.     XtVaGetValues(channel_header,
  408.           XtNlabel,    &str,
  409.           NULL);
  410.     
  411.     /* check for ap defaults */
  412.     if (lexequ(str, "channelHeader") == 0) {
  413.         printf("The application defaults aren't installed!\n");
  414.         exit(1);
  415.     }
  416.     channel_commands = XtVaCreateManagedWidget("channelCommands",
  417.                     boxWidgetClass,
  418.                     channel_form,
  419.                     NULL);
  420.  
  421.     channel_info = XtVaCreateManagedWidget("channelInfo",
  422.                     commandWidgetClass,
  423.                     channel_commands,
  424.                     XtNlabel,    "info",
  425.                     NULL);
  426.     if (normalFont != NULL)
  427.         XtSetValues(channel_info,argList, 1);
  428.     XtAddCallback(channel_info, XtNcallback, Command, chaninfo);
  429.  
  430.     channel_next = XtVaCreateManagedWidget("channelNext",
  431.                     commandWidgetClass,
  432.                     channel_commands,
  433.                     NULL);
  434.     if (normalFont != NULL)
  435.         XtSetValues(channel_next,argList, 1);
  436.     XtAddCallback(channel_next, XtNcallback, Command, channext);
  437.  
  438.     channel_prev = XtVaCreateManagedWidget("channelPrev",
  439.                     commandWidgetClass,
  440.                     channel_commands,
  441.                     NULL);
  442.     if (normalFont != NULL)
  443.         XtSetValues(channel_prev,argList, 1);
  444.     XtAddCallback(channel_prev, XtNcallback, Command, chanprev);
  445.  
  446.  
  447.     channel_stop = XtVaCreateManagedWidget("channelStop",
  448.                     commandWidgetClass,
  449.                     channel_commands,
  450.                     XtNlabel,    "disable",
  451.                     NULL);
  452.     if (normalFont != NULL)
  453.         XtSetValues(channel_stop,argList, 1);
  454.  
  455.     XtAddCallback(channel_stop, XtNcallback, Command, chanstop);
  456.  
  457.     channel_start = XtVaCreateManagedWidget("channelStart",
  458.                      commandWidgetClass,
  459.                      channel_commands,
  460.                      XtNlabel,    "enable",
  461.                      NULL);
  462.     if (normalFont != NULL)
  463.         XtSetValues(channel_start,argList, 1);
  464.  
  465.     XtAddCallback(channel_start, XtNcallback, Command, chanstart);
  466.  
  467.     channel_clear = XtVaCreateManagedWidget("channelClear",
  468.                      commandWidgetClass,
  469.                      channel_commands,
  470.                      NULL);
  471.     if (normalFont != NULL)
  472.         XtSetValues(channel_clear,argList, 1);
  473.  
  474.     XtAddCallback(channel_clear, XtNcallback, Command, chanclear);
  475.  
  476.     channel_cacheadd = XtVaCreateManagedWidget("channelCacheadd",
  477.                     commandWidgetClass,
  478.                     channel_commands,
  479.                     NULL);
  480.     if (normalFont != NULL)
  481.         XtSetValues(channel_cacheadd,argList, 1);
  482.  
  483.     XtAddCallback(channel_cacheadd, XtNcallback, Command, chancacheadd);
  484.  
  485.     channel_downforce = XtVaCreateManagedWidget("channelDownforce",
  486.                      commandWidgetClass,
  487.                      channel_commands,
  488.                      NULL);
  489.     if (normalFont != NULL)
  490.         XtSetValues(channel_downforce,argList, 1);
  491.  
  492.     XtAddCallback (channel_downforce, XtNcallback, Command, chandownforce);
  493.  
  494.  
  495.     currentchan = NULL;
  496.     read_currentchan = 0;
  497.     curlabel = create_channel_header();
  498.     channel_label = XtVaCreateManagedWidget("channelLabel",
  499.                      labelWidgetClass,
  500.                      channel_form,
  501.                      XtNlabel,    curlabel,
  502.                      NULL);
  503.     free(curlabel);
  504.     if (normalFont != NULL)
  505.         XtSetValues(channel_label,argList, 1);
  506.  
  507.     temp_form = XtVaCreateManagedWidget("channelForm2",
  508.                  formWidgetClass,
  509.                  mainvpane,
  510.                  NULL);
  511.  
  512.     channel_viewport = XtVaCreateManagedWidget("channelViewport",
  513.                     viewportWidgetClass,
  514.                     temp_form,
  515.                     NULL);
  516.     
  517.     channels = XtVaCreateManagedWidget("channels",
  518.                 boxWidgetClass,
  519.                 channel_viewport,
  520.                 XtNvSpace,    (2*max_chan_border +1),
  521.                 NULL);
  522.  
  523.     channel_all = XtVaCreateManagedWidget("channelAllViewport",
  524.                           viewportWidgetClass,
  525.                           temp_form,
  526.                           NULL);
  527.     channel_all_form = XtVaCreateManagedWidget("channelAll",
  528.                            formWidgetClass,
  529.                            channel_all,
  530.                            NULL);
  531.     /* channel info widgets */
  532.     channel_all_list = XtVaCreateManagedWidget("channelAllList",
  533.                            listWidgetClass,
  534.                            channel_all_form,
  535.                            NULL);
  536.     if (normalFont != NULL)
  537.         XtSetValues(channel_all_list, argList, 1);
  538.  
  539.     XtSetMappedWhenManaged(channel_form, False);
  540.     XtSetSensitive(channel_commands,FALSE);
  541. }
  542.  
  543. Widget    control_vpane;
  544.  
  545. static void create_controlwidgets()
  546. {
  547.     control_form = XtVaCreateManagedWidget("controlForm",
  548.                     formWidgetClass,
  549.                     switchform,
  550.                     NULL);
  551.  
  552.     control_vpane = XtVaCreateManagedWidget("controlVpane",
  553.                      panedWidgetClass,
  554.                      control_form,
  555.                      NULL);
  556.     create_mtawidgets();
  557.     create_msgwidgets();
  558. }
  559.  
  560. Widget        mta_divider,
  561.         mta_commands,
  562.         mta_stop,
  563.         mta_start,
  564.         mta_clear,
  565.         mta_cacheadd,
  566.         mta_force,
  567.         mta_downforce,
  568.         mta_label,
  569.         mta_info,
  570.         mta_next,
  571.         mta_prev,
  572.         mta_all,
  573.         mta_all_form,
  574.         mta_all_list,
  575.         mta_viewport,
  576.         mtas;
  577. extern struct mta_struct    *currentmta;
  578. extern int            read_currentmta;
  579. extern int            max_mta_border;
  580. extern char            *create_mta_header();
  581. char                *mta_info_str;
  582. int                mta_info_strlen;
  583.  
  584. static void create_mtawidgets()
  585. {
  586.     Widget    temp_form;
  587.  
  588.     mta_form = XtVaCreateManagedWidget("mtaForm",
  589.                 formWidgetClass,
  590.                 control_vpane,
  591.                 NULL);
  592.  
  593.     mta_divider = XtVaCreateManagedWidget("mtaDivider",
  594.                    labelWidgetClass,
  595.                    mta_form,
  596.                    NULL);
  597.     if (normalFont != NULL)
  598.         XtSetValues(mta_divider,argList, 1);
  599.  
  600.     mta_commands = XtVaCreateManagedWidget("mtaCommands",
  601.                     boxWidgetClass,
  602.                     mta_form,
  603.                     NULL);
  604.     XtSetSensitive(mta_commands, FALSE);
  605.  
  606.     mta_info = XtVaCreateManagedWidget("mtaInfo",
  607.                 commandWidgetClass,
  608.                 mta_commands,
  609.                 XtNlabel,    "info",
  610.                 NULL);
  611.     if (normalFont != NULL)
  612.         XtSetValues(mta_info,argList, 1);
  613.  
  614.     XtAddCallback(mta_info, XtNcallback, Command, mtainfo);
  615.  
  616.     mta_next = XtVaCreateManagedWidget("mtaNext",
  617.                 commandWidgetClass,
  618.                 mta_commands,
  619.                 NULL);
  620.     if (normalFont != NULL)
  621.         XtSetValues(mta_next,argList, 1);
  622.  
  623.     XtAddCallback(mta_next, XtNcallback, Command, mtanext);
  624.  
  625.     mta_prev = XtVaCreateManagedWidget("mtaPrev",
  626.                 commandWidgetClass,
  627.                 mta_commands,
  628.                 NULL);
  629.     if (normalFont != NULL)
  630.         XtSetValues(mta_prev,argList, 1);
  631.  
  632.     XtAddCallback(mta_prev, XtNcallback, Command, mtaprev);
  633.  
  634.     mta_stop = XtVaCreateManagedWidget("mtaStop",
  635.                 commandWidgetClass,
  636.                 mta_commands,
  637.                 XtNlabel,    "disable",
  638.                 NULL);
  639.     if (normalFont != NULL)
  640.         XtSetValues(mta_stop,argList, 1);
  641.  
  642.     XtAddCallback(mta_stop, XtNcallback, Command, mtastop);
  643.  
  644.     mta_start = XtVaCreateManagedWidget("mtaStart",
  645.                  commandWidgetClass,
  646.                  mta_commands,
  647.                  XtNlabel,    "enable",
  648.                  NULL);
  649.     if (normalFont != NULL)
  650.         XtSetValues(mta_start,argList, 1);
  651.  
  652.     XtAddCallback(mta_start, XtNcallback, Command, mtastart);
  653.  
  654.     mta_clear = XtVaCreateManagedWidget("mtaClear",
  655.                  commandWidgetClass,
  656.                  mta_commands,
  657.                  NULL);
  658.     if (normalFont != NULL)
  659.         XtSetValues(mta_clear,argList, 1);
  660.  
  661.     XtAddCallback(mta_clear, XtNcallback, Command, mtaclear);
  662.  
  663.     mta_cacheadd = XtVaCreateManagedWidget("mtaCacheadd",
  664.                     commandWidgetClass,
  665.                     mta_commands,
  666.                     NULL);
  667.     if (normalFont != NULL)
  668.         XtSetValues(mta_cacheadd,argList, 1);
  669.  
  670.     XtAddCallback(mta_cacheadd, XtNcallback, Command, mtacacheadd);
  671.  
  672.     mta_force = XtVaCreateManagedWidget("mtaForce",
  673.                  commandWidgetClass,
  674.                  mta_commands,
  675.                  NULL);
  676.     if (normalFont != NULL)
  677.         XtSetValues(mta_force,argList, 1);
  678.  
  679.     XtAddCallback(mta_force, XtNcallback, Command, mtaforce);
  680.  
  681.     mta_downforce = XtVaCreateManagedWidget("mtaDownforce",
  682.                      commandWidgetClass,
  683.                      mta_commands,
  684.                      NULL);
  685.     if (normalFont != NULL)
  686.         XtSetValues(mta_downforce,argList, 1);
  687.  
  688.     XtAddCallback (mta_downforce, XtNcallback, Command, mtadownforce);
  689.  
  690.     currentmta = NULL;
  691.     read_currentmta = 0;
  692.     curlabel = create_mta_header();
  693.     mta_label = XtVaCreateManagedWidget("mtaLabel",
  694.                  labelWidgetClass,
  695.                  mta_form,
  696.                  XtNlabel, curlabel,
  697.                  NULL);
  698.     free(curlabel);
  699.     if (normalFont != NULL)
  700.         XtSetValues(mta_label,argList, 1);
  701.  
  702.     temp_form = XtVaCreateManagedWidget("mtaForm2",
  703.                  formWidgetClass,
  704.                  control_vpane,
  705.                  NULL);
  706.  
  707.     mta_viewport = XtVaCreateManagedWidget("mtaViewport",
  708.                     viewportWidgetClass,
  709.                     temp_form,
  710.                     NULL);
  711.     mtas = XtVaCreateManagedWidget("mtas",
  712.                 boxWidgetClass,
  713.                 mta_viewport,
  714.                 XtNdefaultDistance, (2*max_mta_border+1),
  715.                 NULL);
  716.     mta_all = XtVaCreateManagedWidget("mtaAllViewport",
  717.                    viewportWidgetClass,
  718.                    temp_form,
  719.                    NULL);
  720.     mta_all_form = XtVaCreateManagedWidget("mtaAll",
  721.                            formWidgetClass,
  722.                            mta_all,
  723.                            NULL);
  724.     mta_all_list = XtVaCreateManagedWidget("mtaAllList",
  725.                            listWidgetClass,
  726.                            mta_all_form,
  727.                            NULL);
  728.     if (normalFont != NULL)
  729.         XtSetValues(mta_all_list, argList, 1);
  730. }
  731.  
  732. Widget        msg_divider,
  733.         msg_commands,
  734.         msg_stop,
  735.         msg_start,
  736.         msg_clear,
  737.         msg_cacheadd,
  738.         msg_force,
  739.         msg_label,
  740.         msg_info,
  741.         msg_next,
  742.         msg_prev,
  743.         msg_all,
  744.         msg_all_form,
  745.         msg_all_list,
  746.         msgs_showall,
  747.         msg_viewport,
  748.         msgs;
  749.  
  750. extern struct msg_struct    *currentmsg;
  751. extern char            *create_msg_header();
  752. extern void            MsgsShowAll();
  753. char                *msg_info_str;
  754. int                msg_info_strlen;
  755.  
  756. static void create_msgwidgets()
  757. {
  758.     Widget    temp_form;
  759.  
  760.     msg_form = XtVaCreateManagedWidget("msgForm",
  761.                 formWidgetClass,
  762.                 control_vpane,
  763.                 NULL);
  764.  
  765.     msg_divider = XtVaCreateManagedWidget("msgDivider",
  766.                    labelWidgetClass,
  767.                    msg_form,
  768.                    NULL);
  769.     if (normalFont != NULL)
  770.         XtSetValues(msg_divider,argList, 1);
  771.  
  772.     msg_commands = XtVaCreateManagedWidget("msgCommands",
  773.                     boxWidgetClass,
  774.                     msg_form,
  775.                     NULL);
  776.     XtSetSensitive(msg_commands, FALSE);
  777.  
  778.     msg_info = XtVaCreateManagedWidget("msgInfo",
  779.                 commandWidgetClass,
  780.                 msg_commands,
  781.                 XtNlabel,    "info",
  782.                 NULL);
  783.     if (normalFont != NULL)
  784.         XtSetValues(msg_info,argList, 1);
  785.     XtAddCallback(msg_info, XtNcallback, Command, msginfo);
  786.         
  787.     msg_next = XtVaCreateManagedWidget("msgNext",
  788.                 commandWidgetClass,
  789.                 msg_commands,
  790.                 NULL);
  791.     if (normalFont != NULL)
  792.         XtSetValues(msg_next,argList, 1);
  793.     XtAddCallback(msg_next, XtNcallback, Command, msgnext);
  794.         
  795.     msg_prev = XtVaCreateManagedWidget("msgPrev",
  796.                 commandWidgetClass,
  797.                 msg_commands,
  798.                 NULL);
  799.     if (normalFont != NULL)
  800.         XtSetValues(msg_prev,argList, 1);
  801.     XtAddCallback(msg_prev, XtNcallback, Command, msgprev);
  802.         
  803.     msgs_showall = XtVaCreateManagedWidget("msgShowall",
  804.                     commandWidgetClass,
  805.                     msg_commands,
  806.                     NULL);
  807.     if (normalFont != NULL)
  808.         XtSetValues(msgs_showall,argList, 1);
  809.     XtAddCallback(msgs_showall, XtNcallback, MsgsShowAll, NULL);
  810.  
  811.     msg_stop = XtVaCreateManagedWidget("msgStop",
  812.                 commandWidgetClass,
  813.                 msg_commands,
  814.                 XtNlabel, "freeze",
  815.                 NULL);
  816.     if (normalFont != NULL)
  817.         XtSetValues(msg_stop,argList, 1);
  818.     XtAddCallback(msg_stop, XtNcallback, Command, msgstop);
  819.  
  820.     msg_start = XtVaCreateManagedWidget("msgStart",
  821.                  commandWidgetClass,
  822.                  msg_commands,
  823.                  XtNlabel,    "thaw",
  824.                  NULL);
  825.     if (normalFont != NULL)
  826.         XtSetValues(msg_start,argList, 1);
  827.     XtAddCallback(msg_start, XtNcallback, Command, msgstart);
  828.  
  829.     msg_clear = XtVaCreateManagedWidget("msgClear",
  830.                  commandWidgetClass,
  831.                  msg_commands,
  832.                  NULL);
  833.     if (normalFont != NULL)
  834.         XtSetValues(msg_clear,argList, 1);
  835.     XtAddCallback(msg_clear, XtNcallback, Command, msgclear);
  836.  
  837.     msg_cacheadd = XtVaCreateManagedWidget("msgCacheadd",
  838.                     commandWidgetClass,
  839.                     msg_commands,
  840.                     NULL);
  841.     if (normalFont != NULL)
  842.         XtSetValues(msg_cacheadd,argList, 1);
  843.  
  844.     XtAddCallback(msg_cacheadd, XtNcallback, Command, msgcacheadd);
  845.  
  846.     msg_force = XtVaCreateManagedWidget("msgForce",
  847.                  commandWidgetClass,
  848.                  msg_commands,
  849.                  NULL);
  850.     if (normalFont != NULL)
  851.         XtSetValues(msg_force,argList, 1);
  852.  
  853.     XtAddCallback(msg_force, XtNcallback, Command, msgforce);
  854.  
  855.     currentmsg = NULL;
  856.     curlabel = create_msg_header();
  857.     msg_label = XtVaCreateManagedWidget("msgLabel",
  858.                  labelWidgetClass,
  859.                  msg_form,
  860.                  XtNlabel, curlabel,
  861.                  NULL);
  862.     free(curlabel);
  863.     if (normalFont != NULL)
  864.         XtSetValues(msg_label,argList, 1);
  865.     temp_form = XtVaCreateManagedWidget("msgForm2",
  866.                  formWidgetClass,
  867.                  control_vpane,
  868.                  NULL);
  869.  
  870.     msg_viewport = XtVaCreateManagedWidget("msgViewport",
  871.                     viewportWidgetClass,
  872.                     temp_form,
  873.                     NULL);
  874.     msgs = XtVaCreateManagedWidget("msgs",
  875.                 formWidgetClass,
  876.                 msg_viewport,
  877.                 NULL);
  878.  
  879.     msg_all = XtVaCreateManagedWidget("msgAllViewport",
  880.                       viewportWidgetClass,
  881.                       temp_form,
  882.                       NULL);
  883.     msg_all_form = XtVaCreateManagedWidget("msgAll",
  884.                            formWidgetClass,
  885.                            msg_all,
  886.                            NULL);
  887.     msg_all_list = XtVaCreateManagedWidget("msgAllList",
  888.                            listWidgetClass,
  889.                            msg_all_form,
  890.                            NULL);
  891.     if (normalFont != NULL)
  892.         XtSetValues(msg_all_list, argList, 1);
  893. }
  894.  
  895. Widget    monitor_form;
  896.  
  897. static void create_monitorwidgets()
  898. {
  899.     Dimension    wid,
  900.             ht;
  901.     XtVaGetValues(control_form,
  902.           XtNwidth,     &wid,
  903.           XtNheight,    &ht,
  904.           NULL);
  905.  
  906.     monitor_viewport = XtVaCreateWidget("monitorViewport",
  907.                     viewportWidgetClass,
  908.                     switchform,
  909.                     XtNwidth,    wid, /*TOTAL_WIDTH,*/
  910.                     XtNheight,    ht,  /* (2*VP_HEIGHT+4*26),*/
  911.                     NULL);
  912.  
  913.     monitor_form = XtVaCreateManagedWidget("monitorForm",
  914.                     formWidgetClass,
  915.                     monitor_viewport,
  916.                     XtNwidth,    wid,
  917.                     XtNheight,    ht,
  918.                     NULL);
  919.     XtManageChild(monitor_viewport);
  920.     XtSetMappedWhenManaged(monitor_viewport, True);
  921.     XtSetMappedWhenManaged(control_form, False);
  922. }
  923.  
  924. /*   */
  925. /* popups */
  926.  
  927. Popup_menu     *yesno,
  928.         *one,
  929.         *two,
  930.         *three,
  931.         *config,
  932.         *connectpopup,
  933.         *qcontrol;
  934. Widget    qversion,
  935.     refresh_toggle,
  936.     reconnect_toggle,
  937.     backoff_toggle,
  938.     confirm_toggle,
  939.     compat_toggle,
  940.     inbounds_toggle,
  941.     heur_toggle,
  942.     percent_form,
  943.     line_form,
  944.     auth_toggle;
  945.  
  946. extern void     previousField(),
  947.         nextField(),
  948.         thisField(),
  949.         myinsert_char(),
  950.         mydelete_char(),
  951.         mymenupopdown(),
  952.         curChan(),
  953.         excl_curChan(),
  954.         readChan(),
  955.         curMta(),
  956.         excl_curMta(),
  957.         readMta(),
  958.         curMsg(),
  959.         excl_curMsg(),
  960.         readMsg(),
  961.         chanMode(),
  962.         chanModeRead(),
  963.         chanRefresh(),
  964.         mtaMode(),
  965.         mtaModeRead(),
  966.         mtaRefresh(),
  967.         QControl(),
  968.         popup_OK(),
  969.         popup_NOTOK(),
  970.         config_OK(),
  971.         connectpopup_OK(),
  972.         configToggle(),
  973.         heurToggle();
  974. extern int    autoRefresh,
  975.         autoReconnect,
  976.         backoff,
  977.         confirm,
  978.         compat,
  979.         displayInactIns,
  980.         auth;
  981. int        newautoRefresh,
  982.         newautoReconnect,
  983.         newbackoff,
  984.         newconfirm,
  985.         newcompat,
  986.         newdisplayInactIns,
  987.         newauth;
  988. Heuristic    newheur;
  989. extern Heuristic heuristic;
  990. unsigned long    newTimes;
  991.  
  992. XtActionsRec    actionTable[] = {
  993. {"previousField",    previousField},
  994. {"nextField",        nextField},
  995. {"thisField",        thisField},
  996. {"myinsert_char",    myinsert_char},
  997. {"mydelete_char",    mydelete_char},
  998. {"mymenupopdown",    mymenupopdown},
  999. {"curChan",        curChan},
  1000. {"excl_curChan",    excl_curChan},
  1001. {"readChan",        readChan},
  1002. {"curMta",        curMta},
  1003. {"excl_curMta",        excl_curMta},
  1004. {"readMta",        readMta},
  1005. {"curMsg",        curMsg},
  1006. {"excl_curMsg",        excl_curMsg},
  1007. {"readMsg",        readMsg},
  1008. {"chanMode",        chanMode},
  1009. {"chanModeRead",    chanModeRead},
  1010. {"chanRefresh",        chanRefresh},
  1011. {"mtaMode",        mtaMode},
  1012. {"mtaModeRead",        mtaModeRead},
  1013. {"mtaRefresh",        mtaRefresh},
  1014. };
  1015.  
  1016. XtTranslations    channel_monitorTranslations,
  1017.         mta_monitorTranslations,
  1018.         passwdTranslations;
  1019.  
  1020. /*static char    *channel_translationTable =
  1021.     "<Btn1Up>:    curChan() readChan()\n\
  1022.     <Btn2Up>:    excl_curChan()\n\
  1023.     <Btn3Up>:    readChan()\n";*/
  1024. static char    *channel_monitortranslationTable =
  1025.     "<Btn1Up>:    chanModeRead()\n\
  1026.     <Btn2Up>:    chanMode()\n\
  1027.     <Btn3Up>:    chanRefresh()\n";
  1028. /*static char    *mta_translationTable =
  1029.     "<Btn1Up>:    curMta() readMta()\n\
  1030.     <Btn2Up>:    excl_curMta()\n\
  1031.     <Btn3Up>:    readMta()\n";*/
  1032. static char    *mta_monitortranslationTable =
  1033.     "<Btn1Up>:    mtaModeRead()\n\
  1034.     <Btn2Up>:    mtaMode()\n\
  1035.     <Btn3Up>:    mtaRefresh()\n";
  1036. /*static char    *msg_translationTable =
  1037.     "<Btn1Up>:    curMsg() readMsg()\n\
  1038.     <Btn2Up>:    excl_curMsg()\n\
  1039.     <Btn3Up>:    readMsg()\n";*/
  1040. /*static char    *text_translationTable =
  1041.     "<Key>Up:    previousField()\n\
  1042.     <Key>Down:    nextField()\n\
  1043.     <Key>Tab:    nextField()\n\
  1044.     <Btn1Down>:    thisField() select-start()\n";*/
  1045. static char    *passwd_translationTable =
  1046.     "<Key>Up:    previousField()\n\
  1047.     <Key>Down:    nextField()\n\
  1048.     <Key>Tab:    nextField()\n\
  1049.     <Btn1Down>:    thisField()\n\
  1050.     <Key>Delete:    mydelete_char()\n\
  1051.     <Key>BackSpace: mydelete_char()\n\
  1052.     <Key>:        myinsert_char()\n";
  1053. /*static char    *qcontrol_translationTable =
  1054.     "<BtnUp>:    mymenupopdown()\n\
  1055.     <Leave>:    mymenupopdown()\n";*/
  1056.  
  1057. /*static char    *OKAcceleratorTable = 
  1058.     "#override\n\
  1059. <Key>Return:    set() notify()";*/
  1060.  
  1061. static void create_defaultHostspopup()
  1062. {
  1063. }
  1064.  
  1065. static void create_popupwidgets(context)
  1066. XtAppContext    context;
  1067. {
  1068.     Widget    OKwg,
  1069.         NOTOKwg,
  1070.         label,
  1071.         version;
  1072.     Arg    arg[2];
  1073.     int    i;
  1074.     char    *str = NULL;
  1075.     extern char password[];
  1076.     
  1077.     XtAppAddActions(context, actionTable, XtNumber(actionTable));
  1078.     passwdTranslations = XtParseTranslationTable(passwd_translationTable);
  1079.     channel_monitorTranslations = XtParseTranslationTable(channel_monitortranslationTable);
  1080.     mta_monitorTranslations = XtParseTranslationTable(mta_monitortranslationTable);
  1081.     create_defaultHostspopup();
  1082.  
  1083.     XtSetArg(arg[0], XtNallowShellResize, True);
  1084.     XtSetArg(arg[1], XtNinput, True);
  1085.  
  1086.     qcontrol = (Popup_menu *) calloc(1, sizeof(*qcontrol));
  1087.     qcontrol->popup = XtCreatePopupShell("qcontrol",
  1088.                          overrideShellWidgetClass,
  1089.                          qcontrol_command,
  1090.                          arg,
  1091.                          2);
  1092.     qcontrol->form = XtVaCreateManagedWidget("qcontrolForm",
  1093.                       boxWidgetClass,
  1094.                       qcontrol->popup,
  1095.                       NULL);
  1096.  
  1097.     label = XtVaCreateManagedWidget("increaseMaxChannels",
  1098.                  commandWidgetClass,
  1099.                  qcontrol->form,
  1100.                  NULL);
  1101.     XtAddCallback(label, XtNcallback, 
  1102.               QControl, int_Qmgr_QMGROp_increasemaxchans);
  1103.     if (normalFont != NULL)
  1104.         XtSetValues(label,argList, 1);
  1105.     label = XtVaCreateManagedWidget("decreaseMaxChannels",
  1106.                  commandWidgetClass,
  1107.                  qcontrol->form,
  1108.                  NULL);
  1109.     XtAddCallback(label, XtNcallback, 
  1110.               QControl, int_Qmgr_QMGROp_decreasemaxchans);
  1111.     if (normalFont != NULL)
  1112.         XtSetValues(label,argList, 1);
  1113.     
  1114.     label = XtVaCreateManagedWidget("enableSubmission",
  1115.                  commandWidgetClass,
  1116.                  qcontrol->form,
  1117.                  NULL);
  1118.     XtAddCallback(label, XtNcallback, 
  1119.               QControl, int_Qmgr_QMGROp_enableSubmission);
  1120.     if (normalFont != NULL)
  1121.         XtSetValues(label,argList, 1);
  1122.     
  1123.     label = XtVaCreateManagedWidget("disableSubmission",
  1124.                  commandWidgetClass,
  1125.                  qcontrol->form,
  1126.                  NULL);
  1127.     XtAddCallback(label, XtNcallback, 
  1128.               QControl, int_Qmgr_QMGROp_disableSubmission);
  1129.     if (normalFont != NULL)
  1130.         XtSetValues(label,argList, 1);
  1131.     
  1132.     label = XtVaCreateManagedWidget("enableAll",
  1133.                  commandWidgetClass,
  1134.                  qcontrol->form,
  1135.                  NULL);
  1136.     XtAddCallback(label, XtNcallback, 
  1137.               QControl, int_Qmgr_QMGROp_enableAll);
  1138.     if (normalFont != NULL)
  1139.         XtSetValues(label,argList, 1);
  1140.     
  1141.     label = XtVaCreateManagedWidget("disableAll",
  1142.                  commandWidgetClass,
  1143.                  qcontrol->form,
  1144.                  NULL);
  1145.     XtAddCallback(label, XtNcallback, 
  1146.               QControl, int_Qmgr_QMGROp_disableAll);
  1147.     if (normalFont != NULL)
  1148.         XtSetValues(label,argList, 1);
  1149.         
  1150.     label = XtVaCreateManagedWidget("rereadQ",
  1151.                  commandWidgetClass,
  1152.                  qcontrol->form,
  1153.                  NULL);
  1154.     XtAddCallback(label, XtNcallback, 
  1155.               QControl, int_Qmgr_QMGROp_rereadQueue);
  1156.     if (normalFont != NULL)
  1157.         XtSetValues(label,argList, 1);
  1158.     
  1159.     label = XtVaCreateManagedWidget("restartQmgr",
  1160.                  commandWidgetClass,
  1161.                  qcontrol->form,
  1162.                  NULL);
  1163.     XtAddCallback(label, XtNcallback, 
  1164.               QControl, int_Qmgr_QMGROp_restart);
  1165.     if (normalFont != NULL)
  1166.         XtSetValues(label,argList, 1);
  1167.     
  1168.     label = XtVaCreateManagedWidget("gracefulStop",
  1169.                  commandWidgetClass,
  1170.                  qcontrol->form,
  1171.                  NULL);
  1172.     XtAddCallback(label, XtNcallback, 
  1173.               QControl, int_Qmgr_QMGROp_gracefulTerminate);
  1174.     if (normalFont != NULL)
  1175.         XtSetValues(label,argList, 1);
  1176.     
  1177.     label = XtVaCreateManagedWidget("emergencyStop",
  1178.                  commandWidgetClass,
  1179.                  qcontrol->form,
  1180.                  NULL);
  1181.     XtAddCallback(label, XtNcallback, 
  1182.               QControl, int_Qmgr_QMGROp_abort);
  1183.     if (normalFont != NULL)
  1184.         XtSetValues(label,argList, 1);
  1185.     
  1186.     yesno = (Popup_menu *) calloc(1, sizeof(*yesno));
  1187.  
  1188.     yesno->popup = XtCreatePopupShell("yesno_popup",
  1189.                       transientShellWidgetClass,
  1190.                       quit_command,
  1191.                       arg,
  1192.                       2);
  1193.  
  1194.     yesno->form = XtVaCreateManagedWidget("yesnoForm",
  1195.                    formWidgetClass,
  1196.                    yesno->popup,
  1197.                    NULL);
  1198.  
  1199.     OKwg = XtVaCreateManagedWidget("yesnoOK",
  1200.                 commandWidgetClass,
  1201.                 yesno->form,
  1202.                 NULL);
  1203.     if (normalFont != NULL)
  1204.         XtSetValues(OKwg,argList, 1);
  1205.     yesno->op = unknown;
  1206.     XtAddCallback(OKwg, XtNcallback, popup_OK, &(yesno->op));
  1207.  
  1208.     NOTOKwg = XtVaCreateManagedWidget("yesnoNotok",
  1209.                    commandWidgetClass,
  1210.                    yesno->form,
  1211.                    NULL);
  1212.     if (normalFont != NULL)
  1213.         XtSetValues(NOTOKwg,argList, 1);
  1214.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(yesno->op));
  1215.     XtInstallAllAccelerators(yesno->form, yesno->form);
  1216.  
  1217.     one = (Popup_menu *) calloc(1, sizeof(*one));
  1218.     one->tuple = (Popup_tuple *) calloc(1, sizeof(Popup_tuple));
  1219.     one->numberOftuples = 1;
  1220.     one->popup = XtCreatePopupShell("onetext_popup",
  1221.                     transientShellWidgetClass,
  1222.                     quit_command,
  1223.                     arg,
  1224.                     2);
  1225.  
  1226.     one->form = XtVaCreateManagedWidget("oneForm",
  1227.                  formWidgetClass,
  1228.                  one->popup,
  1229.                  NULL);
  1230.  
  1231.     OKwg = XtVaCreateManagedWidget("oneOk",
  1232.                 commandWidgetClass,
  1233.                 one->form,
  1234.                 NULL);
  1235.     one->op = unknown;
  1236.     if (normalFont != NULL)
  1237.         XtSetValues(OKwg,argList, 1);
  1238.     XtAddCallback(OKwg, XtNcallback, popup_OK, &(one->op));
  1239.  
  1240.     NOTOKwg = XtVaCreateManagedWidget("oneNotok",
  1241.                    commandWidgetClass,
  1242.                    one->form,
  1243.                    NULL);
  1244.     if (normalFont != NULL)
  1245.         XtSetValues(NOTOKwg,argList, 1);
  1246.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(one->op));
  1247.  
  1248.     one->tuple[0].label = XtVaCreateManagedWidget("oneLabelOne",
  1249.                        labelWidgetClass,
  1250.                        one->form,
  1251.                        XtNlabel, "clear cache on channel ",
  1252.                        NULL);
  1253.     if (normalFont != NULL)
  1254.         XtSetValues(one->tuple[0].label,argList, 1);
  1255.  
  1256.     if (normalFont != NULL)
  1257.     one->tuple[0].text = XtVaCreateManagedWidget("oneTextOne",
  1258.                       asciiTextWidgetClass,
  1259.                       one->form,
  1260.                              XtNresize, XawtextResizeWidth,
  1261.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1262.                       XtNfont,    normalFont,
  1263.                       NULL);
  1264.     else
  1265.     one->tuple[0].text = XtVaCreateManagedWidget("oneTextOne",
  1266.                       asciiTextWidgetClass,
  1267.                       one->form,
  1268.                              XtNresize, XawtextResizeWidth,
  1269.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1270.                       NULL);
  1271.  
  1272.     XtInstallAllAccelerators(one->tuple[0].text, one->form);
  1273.  
  1274.     two = (Popup_menu *) calloc(1, sizeof(*two));
  1275.     two->tuple = (Popup_tuple *) calloc(2, sizeof(Popup_tuple));
  1276.     two->numberOftuples = 2;
  1277.     two->popup = XtCreatePopupShell("twotext_popup",
  1278.                     transientShellWidgetClass,
  1279.                     quit_command,
  1280.                     arg,
  1281.                     2);
  1282.     two->form  = XtVaCreateManagedWidget("twoForm",
  1283.                   formWidgetClass,
  1284.                   two->popup,
  1285.                   NULL);
  1286.     OKwg = XtVaCreateManagedWidget("twoOk",
  1287.                 commandWidgetClass,
  1288.                 two->form,
  1289.                 NULL);
  1290.     if (normalFont != NULL)
  1291.         XtSetValues(OKwg,argList, 1);
  1292.     two->op = unknown;
  1293.     XtAddCallback(OKwg, XtNcallback, popup_OK, &(two->op));
  1294.  
  1295.     NOTOKwg = XtVaCreateManagedWidget("twoNotok",
  1296.                    commandWidgetClass,
  1297.                    two->form,
  1298.                    NULL);
  1299.     if (normalFont != NULL)
  1300.         XtSetValues(NOTOKwg,argList, 1);
  1301.  
  1302.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(two->op));
  1303.  
  1304.     two->tuple[0].label = XtVaCreateManagedWidget("twoLabelOne",
  1305.                        labelWidgetClass,
  1306.                        two->form,
  1307.                        XtNlabel, "clear cache on channel",
  1308.                        NULL);
  1309.     if (normalFont != NULL)
  1310.         XtSetValues(two->tuple[0].label,argList, 1);
  1311.  
  1312.     if (normalFont != NULL)
  1313.     two->tuple[0].text = XtVaCreateManagedWidget("twoTextOne",
  1314.                       asciiTextWidgetClass,
  1315.                       two->form,
  1316.                       XtNresize, XawtextResizeWidth,
  1317.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1318.                       XtNfont,    normalFont,
  1319.                       NULL);
  1320.     else
  1321.     two->tuple[0].text = XtVaCreateManagedWidget("twoTextOne",
  1322.                       asciiTextWidgetClass,
  1323.                       two->form,
  1324.                       XtNresize, XawtextResizeWidth,
  1325.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1326.                       NULL);
  1327.  
  1328.     two->tuple[1].label = XtVaCreateManagedWidget("twoLabelTwo",
  1329.                        labelWidgetClass,
  1330.                        two->form,
  1331.                        XtNlabel, "clear cache on channel",
  1332.                        NULL);
  1333.     if (normalFont != NULL)
  1334.         XtSetValues(two->tuple[1].label,argList, 1);
  1335.  
  1336.     if (normalFont != NULL)
  1337.     two->tuple[1].text = XtVaCreateManagedWidget("twoTextTwo",
  1338.                       asciiTextWidgetClass,
  1339.                       two->form,
  1340.                       XtNresize, XawtextResizeWidth,
  1341.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1342.                       XtNfont,        normalFont,
  1343.                       NULL);
  1344.     else
  1345.     two->tuple[1].text = XtVaCreateManagedWidget("twoTextTwo",
  1346.                       asciiTextWidgetClass,
  1347.                       two->form,
  1348.                       XtNresize, XawtextResizeWidth,
  1349.                       XtNscrollVertical, XawtextScrollWhenNeeded,
  1350.                       NULL);
  1351.  
  1352.     XtInstallAllAccelerators(two->tuple[0].text, two->form);
  1353.     XtInstallAllAccelerators(two->tuple[1].text, two->form);
  1354.     
  1355.     three = (Popup_menu *) calloc(1, sizeof(*three));
  1356.     three->op = unknown;
  1357.     three->tuple = (Popup_tuple *) calloc(3, sizeof(Popup_tuple));
  1358.     three->numberOftuples = 3;
  1359.     three->popup = XtCreatePopupShell("threetext_popup",
  1360.                       transientShellWidgetClass,
  1361.                       quit_command,
  1362.                       arg,
  1363.                       2);
  1364.     three->form  = XtVaCreateManagedWidget("threeForm",
  1365.                     formWidgetClass,
  1366.                     three->popup,
  1367.                     XtNborderWidth,    0,
  1368.                     NULL);
  1369.     OKwg = XtVaCreateManagedWidget("threeOk",
  1370.                 commandWidgetClass,
  1371.                 three->form,
  1372.                 NULL);
  1373.     if (normalFont != NULL)
  1374.         XtSetValues(OKwg,argList, 1);
  1375.     XtAddCallback(OKwg, XtNcallback, popup_OK, &(three->op));
  1376.  
  1377.     NOTOKwg = XtVaCreateManagedWidget("threeNotok",
  1378.                    commandWidgetClass,
  1379.                    three->form,
  1380.                    NULL);
  1381.     if (normalFont != NULL)
  1382.         XtSetValues(NOTOKwg,argList, 1);
  1383.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(three->op));
  1384.  
  1385.     three->tuple[0].label = XtVaCreateManagedWidget("threeLabelOne",
  1386.                          labelWidgetClass,
  1387.                          three->form,
  1388.                          XtNlabel, "clear cache on channel",
  1389.                          NULL);
  1390.  
  1391.     if (normalFont != NULL)
  1392.         XtSetValues(three->tuple[0].label,argList, 1);
  1393.     if (normalFont != NULL)
  1394.     three->tuple[0].text = XtVaCreateManagedWidget("threeTextOne",
  1395.                         asciiTextWidgetClass,
  1396.                         three->form,
  1397.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1398.                                XtNresize, XawtextResizeWidth,
  1399.                         NULL);
  1400.     else
  1401.     three->tuple[0].text = XtVaCreateManagedWidget("threeTextOne",
  1402.                         asciiTextWidgetClass,
  1403.                         three->form,
  1404.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1405.                                XtNresize, XawtextResizeWidth,
  1406.                         XtNfont,        normalFont,
  1407.                         NULL);
  1408.  
  1409.     three->tuple[1].label = XtVaCreateManagedWidget("threeLabelTwo",
  1410.                          labelWidgetClass,
  1411.                          three->form,
  1412.                          XtNlabel, "clear cache on channel",
  1413.                          NULL);
  1414.     if (normalFont != NULL)
  1415.         XtSetValues(three->tuple[1].label,argList, 1);
  1416.  
  1417.     if (normalFont == NULL)
  1418.     three->tuple[1].text = XtVaCreateManagedWidget("threeTextTwo",
  1419.                         asciiTextWidgetClass,
  1420.                         three->form,
  1421.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1422.                                XtNresize, XawtextResizeWidth,
  1423.                         NULL);
  1424.     else
  1425.     three->tuple[1].text = XtVaCreateManagedWidget("threeTextTwo",
  1426.                         asciiTextWidgetClass,
  1427.                         three->form,
  1428.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1429.                                XtNresize, XawtextResizeWidth,
  1430.                         XtNfont,        normalFont,
  1431.                         NULL);
  1432.  
  1433.     three->tuple[2].label = XtVaCreateManagedWidget("threeLabelThree",
  1434.                          labelWidgetClass,
  1435.                          three->form,
  1436.                          XtNlabel, "clear cache on channel",
  1437.                          NULL);
  1438.     if (normalFont != NULL)
  1439.         XtSetValues(three->tuple[2].label,argList, 1);
  1440.     if (normalFont == NULL)
  1441.     three->tuple[2].text = XtVaCreateManagedWidget("threeTextThree",
  1442.                         asciiTextWidgetClass,
  1443.                         three->form,
  1444.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1445.                                XtNresize, XawtextResizeWidth,
  1446.                         NULL);
  1447.     else
  1448.     three->tuple[2].text = XtVaCreateManagedWidget("threeTextThree",
  1449.                         asciiTextWidgetClass,
  1450.                         three->form,
  1451.                         XtNscrollVertical, XawtextScrollWhenNeeded,
  1452.                                XtNresize, XawtextResizeWidth,
  1453.                         XtNfont,        normalFont,
  1454.                         NULL);
  1455.  
  1456.     XtInstallAllAccelerators(three->tuple[0].text, three->form);
  1457.     XtInstallAllAccelerators(three->tuple[1].text, three->form);
  1458.     XtInstallAllAccelerators(three->tuple[2].text, three->form);
  1459.  
  1460.     config = (Popup_menu *) calloc(1, sizeof(*config));
  1461.     config->op = unknown;
  1462.     config->numberOftuples = 8;
  1463.     config->tuple = (Popup_tuple *) calloc((unsigned)config->numberOftuples,
  1464.                            sizeof(Popup_tuple));
  1465.  
  1466.     config->popup = XtCreatePopupShell("config_popup",
  1467.                        transientShellWidgetClass,
  1468.                        config_command,
  1469.                        arg,
  1470.                        2);
  1471.     config->form = XtVaCreateManagedWidget("configForm",
  1472.                     formWidgetClass,
  1473.                     config->popup,
  1474.                     NULL);
  1475.  
  1476.     OKwg = XtVaCreateManagedWidget("configOk",
  1477.                 commandWidgetClass,
  1478.                 config->form,
  1479.                 NULL);
  1480.     XtAddCallback(OKwg, XtNcallback, config_OK, NULL);
  1481.     if (normalFont != NULL)
  1482.         XtSetValues(OKwg,argList, 1);
  1483.  
  1484.     NOTOKwg = XtVaCreateManagedWidget("configNotok",
  1485.                    commandWidgetClass,
  1486.                    config->form,
  1487.                    NULL);
  1488.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(config->op));
  1489.     if (normalFont != NULL)
  1490.         XtSetValues(NOTOKwg,argList, 1);
  1491.  
  1492.     label = XtVaCreateManagedWidget("versionLabel",
  1493.                  labelWidgetClass,
  1494.                  config->form,
  1495.                  NULL);
  1496.     if (normalFont != NULL)
  1497.         XtSetValues(label,argList, 1);
  1498.     
  1499.     version = XtVaCreateManagedWidget("configVersion",
  1500.                    labelWidgetClass,
  1501.                    config->form,
  1502.                    XtNlabel, ppversion,
  1503.                    NULL);
  1504.     if (normalFont != NULL)
  1505.         XtSetValues(version,argList, 1);
  1506.     
  1507.     label = XtVaCreateManagedWidget("qmgrVersionLabel",
  1508.                  labelWidgetClass,
  1509.                  config->form,
  1510.                  NULL);
  1511.     if (normalFont != NULL)
  1512.         XtSetValues(label,argList, 1);
  1513.     qversion = XtVaCreateManagedWidget("qmgrVersion",
  1514.                    labelWidgetClass,
  1515.                    config->form,
  1516.                    NULL);
  1517.     if (normalFont != NULL)
  1518.         XtSetValues(qversion,argList, 1);
  1519.                    
  1520.     label = XtVaCreateManagedWidget("autoRefreshLabel",
  1521.                  labelWidgetClass,
  1522.                  config->form,
  1523.                  NULL);
  1524.     if (normalFont != NULL)
  1525.         XtSetValues(label,argList, 1);
  1526.     
  1527.     refresh_toggle = XtVaCreateManagedWidget("autoRefreshToggle",
  1528.                       commandWidgetClass,
  1529.                       config->form,
  1530.                       XtNlabel, (autoRefresh == TRUE) ? "enabled" : "disabled",
  1531.                       NULL);
  1532.     if (normalFont != NULL)
  1533.         XtSetValues(refresh_toggle,argList, 1);
  1534.  
  1535.     XtAddCallback(refresh_toggle, XtNcallback, configToggle, &newautoRefresh);
  1536.                       
  1537.     config->tuple[REFRESH].label = XtVaCreateManagedWidget("refreshIntervalLabel",
  1538.                             labelWidgetClass,
  1539.                             config->form,
  1540.                             NULL);
  1541.     if (normalFont != NULL)
  1542.         XtSetValues(config->tuple[REFRESH].label,argList, 1);
  1543.  
  1544.     if (normalFont == NULL)
  1545.     config->tuple[REFRESH].text = XtVaCreateManagedWidget("refreshIntervalText",
  1546.                            asciiTextWidgetClass,
  1547.                            config->form,
  1548.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1549.                                   XtNresize, XawtextResizeWidth,
  1550.                            NULL);
  1551.     else
  1552.     config->tuple[REFRESH].text = XtVaCreateManagedWidget("refreshIntervalText",
  1553.                            asciiTextWidgetClass,
  1554.                            config->form,
  1555.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1556.                                   XtNresize, XawtextResizeWidth,
  1557.                            XtNfont,        normalFont,
  1558.                            NULL);
  1559.  
  1560.     config->tuple[INACTIVE].label = XtVaCreateManagedWidget("inactiveLabel",
  1561.                              labelWidgetClass,
  1562.                              config->form,
  1563.                              NULL);
  1564.     if (normalFont != NULL)
  1565.         XtSetValues(config->tuple[INACTIVE].label,argList, 1);
  1566.  
  1567.     if (normalFont == NULL)
  1568.     config->tuple[INACTIVE].text = XtVaCreateManagedWidget("inactiveText",
  1569.                             asciiTextWidgetClass,
  1570.                             config->form,
  1571.                             XtNscrollVertical, XawtextScrollWhenNeeded,
  1572.                                    XtNresize, XawtextResizeWidth,
  1573.                             NULL);
  1574.     else
  1575.     config->tuple[INACTIVE].text = XtVaCreateManagedWidget("inactiveText",
  1576.                             asciiTextWidgetClass,
  1577.                             config->form,
  1578.                             XtNscrollVertical, XawtextScrollWhenNeeded,
  1579.                                    XtNresize, XawtextResizeWidth,
  1580.                             XtNfont,        normalFont,
  1581.                             NULL);
  1582.  
  1583.     label = XtVaCreateManagedWidget("autoReconnectLabel",
  1584.                  labelWidgetClass,
  1585.                  config->form,
  1586.                  NULL);
  1587.     if (normalFont != NULL)
  1588.         XtSetValues(label,argList, 1);
  1589.     
  1590.     reconnect_toggle = XtVaCreateManagedWidget("autoReconnectToggle",
  1591.                     commandWidgetClass,
  1592.                     config->form,
  1593.                     XtNlabel, (autoReconnect == TRUE) ? "enabled" : "disabled",
  1594.                     NULL);
  1595.     if (normalFont != NULL)
  1596.         XtSetValues(reconnect_toggle,argList, 1);
  1597.     XtAddCallback(reconnect_toggle, XtNcallback, configToggle, &newautoReconnect);
  1598.  
  1599.     config->tuple[START].label = XtVaCreateManagedWidget("arStartLabel",
  1600.                           labelWidgetClass,
  1601.                           config->form,
  1602.                           NULL);
  1603.     if (normalFont != NULL)
  1604.         XtSetValues(config->tuple[START].label,argList, 1);
  1605.  
  1606.     if (normalFont == NULL)
  1607.     config->tuple[START].text = XtVaCreateManagedWidget("arStartText",
  1608.                          asciiTextWidgetClass,
  1609.                          config->form,
  1610.                          XtNscrollVertical, XawtextScrollWhenNeeded,
  1611.                                 XtNresize, XawtextResizeWidth,
  1612.                          NULL);
  1613.     else
  1614.     config->tuple[START].text = XtVaCreateManagedWidget("arStartText",
  1615.                          asciiTextWidgetClass,
  1616.                          config->form,
  1617.                          XtNscrollVertical, XawtextScrollWhenNeeded,
  1618.                                 XtNresize, XawtextResizeWidth,
  1619.                          XtNfont,        normalFont,
  1620.                          NULL);
  1621.  
  1622.     label = XtVaCreateManagedWidget("backOffLabel",
  1623.                  labelWidgetClass,
  1624.                  config->form,
  1625.                  NULL);
  1626.     if (normalFont != NULL)
  1627.         XtSetValues(label,argList, 1);
  1628.  
  1629.     backoff_toggle = XtVaCreateManagedWidget("backOffToggle",
  1630.                       commandWidgetClass,
  1631.                       config->form,
  1632.                       XtNlabel, (backoff == TRUE) ? "enabled" : "disabled",
  1633.                       NULL);
  1634.     if (normalFont != NULL)
  1635.         XtSetValues(backoff_toggle,argList, 1);
  1636.  
  1637.     XtAddCallback(backoff_toggle, XtNcallback, configToggle, &newbackoff);
  1638.  
  1639.     config->tuple[BACKOFF].label = XtVaCreateManagedWidget("boIncLabel",
  1640.                             labelWidgetClass,
  1641.                             config->form,
  1642.                             NULL);
  1643.     if (normalFont != NULL)
  1644.         XtSetValues(config->tuple[BACKOFF].label,argList, 1);
  1645.  
  1646.  
  1647.     if (normalFont == NULL)
  1648.     config->tuple[BACKOFF].text = XtVaCreateManagedWidget("boIncText",
  1649.                            asciiTextWidgetClass,
  1650.                            config->form,
  1651.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1652.                                   XtNresize, XawtextResizeWidth,
  1653.                            NULL);
  1654.     else
  1655.     config->tuple[BACKOFF].text = XtVaCreateManagedWidget("boIncText",
  1656.                            asciiTextWidgetClass,
  1657.                            config->form,
  1658.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1659.                                   XtNresize, XawtextResizeWidth,
  1660.                            XtNfont,        normalFont,
  1661.                            NULL);
  1662.                    
  1663.     config->tuple[CONNECTMAX].label = XtVaCreateManagedWidget("maxRCIntLabel",
  1664.                                labelWidgetClass,
  1665.                                config->form,
  1666.                                NULL);
  1667.     if (normalFont != NULL)
  1668.         XtSetValues(config->tuple[CONNECTMAX].label,argList, 1);
  1669.  
  1670.     if (normalFont == NULL)
  1671.     config->tuple[CONNECTMAX].text = XtVaCreateManagedWidget("maxRCIntText",
  1672.                               asciiTextWidgetClass,
  1673.                               config->form,
  1674.                               XtNscrollVertical, XawtextScrollWhenNeeded,
  1675.                                  XtNresize, XawtextResizeWidth,
  1676.                               NULL);
  1677.     else
  1678.     config->tuple[CONNECTMAX].text = XtVaCreateManagedWidget("maxRCIntText",
  1679.                               asciiTextWidgetClass,
  1680.                               config->form,
  1681.                               XtNscrollVertical, XawtextScrollWhenNeeded,
  1682.                                  XtNresize, XawtextResizeWidth,
  1683.                               XtNfont,        normalFont,
  1684.                               NULL);
  1685.  
  1686.     label = XtVaCreateManagedWidget("confPopupLabel",
  1687.                  labelWidgetClass,
  1688.                  config->form,
  1689.                  NULL);
  1690.     if (normalFont != NULL)
  1691.         XtSetValues(label,argList, 1);
  1692.     confirm_toggle = XtVaCreateManagedWidget ("confPopupToggle",
  1693.                        commandWidgetClass,
  1694.                        config->form,
  1695.                        XtNlabel, (confirm == TRUE) ? "enabled" : "disabled",
  1696.                        NULL);
  1697.     if (normalFont != NULL)
  1698.         XtSetValues(confirm_toggle,argList, 1);
  1699.     XtAddCallback(confirm_toggle, XtNcallback, configToggle, &newconfirm);
  1700.  
  1701.     label = XtVaCreateManagedWidget("compatPopupLabel",
  1702.                  labelWidgetClass,
  1703.                  config->form,
  1704.                  NULL);
  1705.     if (normalFont != NULL)
  1706.         XtSetValues(label,argList, 1);
  1707.     compat_toggle = XtVaCreateManagedWidget ("compatPopupToggle",
  1708.                        commandWidgetClass,
  1709.                        config->form,
  1710.                        XtNlabel, (compat == TRUE) ? "enabled" : "disabled",
  1711.                        NULL);
  1712.     if (normalFont != NULL)
  1713.         XtSetValues(compat_toggle,argList, 1);
  1714.     XtAddCallback(compat_toggle, XtNcallback, configToggle, &newcompat);
  1715.  
  1716.     label = XtVaCreateManagedWidget("inboundPopupLabel",
  1717.                  labelWidgetClass,
  1718.                  config->form,
  1719.                  NULL);
  1720.     if (normalFont != NULL)
  1721.         XtSetValues(label,argList, 1);
  1722.     inbounds_toggle = XtVaCreateManagedWidget ("inboundPopupToggle",
  1723.                        commandWidgetClass,
  1724.                        config->form,
  1725.                        XtNlabel, (displayInactIns == TRUE) ? "enabled" : "disabled",
  1726.                        NULL);
  1727.     if (normalFont != NULL)
  1728.         XtSetValues(inbounds_toggle,argList, 1);
  1729.     XtAddCallback(inbounds_toggle, XtNcallback, configToggle, &newdisplayInactIns);
  1730.  
  1731.     label = XtVaCreateManagedWidget ("heurLabel",
  1732.                   labelWidgetClass,
  1733.                   config->form,
  1734.                   NULL);
  1735.     if (normalFont != NULL)
  1736.         XtSetValues(label,argList, 1);
  1737.     
  1738.     switch (heuristic) {
  1739.         case percentage:
  1740.         str = PERCENT_BASED;
  1741.         break;
  1742.         case all:
  1743.         str = ALL_BASED;
  1744.         break;
  1745.         default:
  1746.         heuristic = line;
  1747.         case line:
  1748.         str = LINE_BASED;
  1749.         break;
  1750.         case chanonly:
  1751.         str = CHANONLY_BASED;
  1752.         break;
  1753.     }
  1754.     heur_toggle = XtVaCreateManagedWidget("heurToggle",
  1755.                    commandWidgetClass,
  1756.                    config->form,
  1757.                    XtNlabel, str,
  1758.                    NULL);
  1759.     newheur = heuristic;
  1760.     if (normalFont != NULL)
  1761.         XtSetValues(heur_toggle,argList, 1);
  1762.     XtAddCallback(heur_toggle, XtNcallback, heurToggle, &newheur);
  1763.  
  1764.     percent_form = XtVaCreateManagedWidget("percentForm",
  1765.                     formWidgetClass,
  1766.                     config->form,
  1767.                     NULL);    
  1768.  
  1769.     config->tuple[PERCENT].label = XtVaCreateManagedWidget ("percentLabel",
  1770.                              labelWidgetClass,
  1771.                              percent_form,
  1772.                              NULL);
  1773.     if (normalFont != NULL)
  1774.         XtSetValues(config->tuple[PERCENT].label,argList, 1);
  1775.     if (normalFont == NULL)
  1776.     config->tuple[PERCENT].text = XtVaCreateManagedWidget("percentText",
  1777.                            asciiTextWidgetClass,
  1778.                            percent_form,
  1779.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1780.                                   XtNresize, XawtextResizeWidth,
  1781.                            NULL);
  1782.     else
  1783.     config->tuple[PERCENT].text = XtVaCreateManagedWidget("percentText",
  1784.                            asciiTextWidgetClass,
  1785.                            percent_form,
  1786.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1787.                                   XtNresize, XawtextResizeWidth,
  1788.                            XtNfont,        normalFont,
  1789.                            NULL);
  1790.  
  1791.     config->tuple[MINBADMTA].label = XtVaCreateManagedWidget ("numBadMtasLabel",
  1792.                              labelWidgetClass,
  1793.                              percent_form,
  1794.                              NULL);
  1795.     if (normalFont != NULL)
  1796.         XtSetValues(config->tuple[MINBADMTA].label,argList, 1);
  1797.     if (normalFont == NULL)
  1798.     config->tuple[MINBADMTA].text = XtVaCreateManagedWidget("numBadMtasText",
  1799.                            asciiTextWidgetClass,
  1800.                            percent_form,
  1801.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1802.                                 XtNresize, XawtextResizeWidth,
  1803.                            NULL);
  1804.     else
  1805.     config->tuple[MINBADMTA].text = XtVaCreateManagedWidget("numBadMtasText",
  1806.                            asciiTextWidgetClass,
  1807.                            percent_form,
  1808.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1809.                                 XtNresize, XawtextResizeWidth,
  1810.                              XtNfont,        normalFont,
  1811.                            NULL);
  1812.  
  1813.     line_form = XtVaCreateManagedWidget("lineForm",
  1814.                  formWidgetClass,
  1815.                  config->form,
  1816.                  NULL);
  1817.     config->tuple[LINEMAX].label = XtVaCreateManagedWidget ("lineLabel",
  1818.                              labelWidgetClass,
  1819.                              line_form,
  1820.                              NULL);
  1821.     if (normalFont != NULL)
  1822.         XtSetValues(config->tuple[LINEMAX].label,argList, 1);
  1823.     if (normalFont == NULL)
  1824.         config->tuple[LINEMAX].text = XtVaCreateManagedWidget("lineText",
  1825.                            asciiTextWidgetClass,
  1826.                            line_form,
  1827.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1828.                                       XtNresize, XawtextResizeWidth,
  1829.                            NULL);
  1830.     else         config->tuple[LINEMAX].text = XtVaCreateManagedWidget("lineText",
  1831.                            asciiTextWidgetClass,
  1832.                            line_form,
  1833.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1834.                                           XtNresize, XawtextResizeWidth,
  1835.               XtNfont,        normalFont,
  1836.                            NULL);
  1837.  
  1838.     switch (heuristic) {
  1839.         case percentage:
  1840.         XtSetMappedWhenManaged (line_form, FALSE);
  1841.         break;
  1842.         case line:
  1843.         XtSetMappedWhenManaged (percent_form, FALSE);
  1844.         break;
  1845.         case all:
  1846.         case chanonly:
  1847.         XtSetMappedWhenManaged (line_form, FALSE);
  1848.         XtSetMappedWhenManaged (percent_form, FALSE);
  1849.         break;
  1850.     }
  1851.  
  1852.     
  1853.     for (i = 0; i < config->numberOftuples; i++) {
  1854.         XtInstallAllAccelerators(config->tuple[i].text, config->form);
  1855.     }
  1856.  
  1857.     connectpopup = (Popup_menu *) calloc(1, sizeof(Popup_menu));
  1858.     connectpopup->op = connect;
  1859.     connectpopup->tuple = (Popup_tuple *) calloc(4, sizeof(Popup_tuple));
  1860.     connectpopup->numberOftuples = 4;
  1861.  
  1862.     connectpopup->popup = XtCreatePopupShell("connectpopup",
  1863.                          transientShellWidgetClass,
  1864.                          connect_command,
  1865.                          arg,
  1866.                          2);
  1867.     connectpopup->form = XtVaCreateManagedWidget("connectForm",
  1868.                       formWidgetClass,
  1869.                       connectpopup->popup,
  1870.                       NULL);
  1871.     OKwg = XtVaCreateManagedWidget("connectOk",
  1872.                 commandWidgetClass,
  1873.                 connectpopup->form,
  1874.                 NULL);
  1875.     XtAddCallback(OKwg, XtNcallback, connectpopup_OK, NULL);
  1876.     if (normalFont != NULL)
  1877.         XtSetValues(OKwg,argList, 1);
  1878.     NOTOKwg = XtVaCreateManagedWidget("connectNotok",
  1879.                    commandWidgetClass,
  1880.                    connectpopup->form,
  1881.                    NULL);
  1882.     if (normalFont != NULL)
  1883.         XtSetValues(NOTOKwg,argList, 1);
  1884.     XtAddCallback(NOTOKwg, XtNcallback, popup_NOTOK, &(connectpopup->op));
  1885.  
  1886.     connectpopup->tuple[0].label = XtVaCreateManagedWidget("connectToLabel",
  1887.                             labelWidgetClass,
  1888.                             connectpopup->form,
  1889.                             NULL);
  1890.     if (normalFont != NULL)
  1891.         XtSetValues(connectpopup->tuple[0].label,argList, 1);
  1892.     if (normalFont != NULL) 
  1893.     connectpopup->tuple[0].text = XtVaCreateManagedWidget("connectToText",
  1894.                            asciiTextWidgetClass,
  1895.                            connectpopup->form,
  1896.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1897.                                   XtNresize, XawtextResizeWidth,
  1898.                            XtNfont,        normalFont,
  1899.                            NULL);
  1900.     else
  1901.     connectpopup->tuple[0].text = XtVaCreateManagedWidget("connectToText",
  1902.                            asciiTextWidgetClass,
  1903.                            connectpopup->form,
  1904.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1905.                                   XtNresize, XawtextResizeWidth,
  1906.                            XtNfont,        normalFont,
  1907.                            NULL);
  1908.     connectpopup->tuple[1].label = XtVaCreateManagedWidget("taiFileLabel",
  1909.                             labelWidgetClass,
  1910.                             connectpopup->form,
  1911.                             NULL);
  1912.     if (normalFont != NULL)
  1913.         XtSetValues(connectpopup->tuple[1].label,argList, 1);
  1914.     if (normalFont == NULL)
  1915.         connectpopup->tuple[1].text = XtVaCreateManagedWidget("taiFileText",
  1916.                            asciiTextWidgetClass,
  1917.                            connectpopup->form,
  1918.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1919.                                       XtNresize, XawtextResizeWidth,
  1920.                            NULL);
  1921.     else
  1922.         connectpopup->tuple[1].text = XtVaCreateManagedWidget("taiFileText",
  1923.                            asciiTextWidgetClass,
  1924.                            connectpopup->form,
  1925.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1926.                                       XtNresize, XawtextResizeWidth,
  1927.                                XtNfont,        normalFont,
  1928.                            NULL);
  1929.  
  1930.     label = XtVaCreateManagedWidget("authLabel",
  1931.                  labelWidgetClass,
  1932.                  connectpopup->form,
  1933.                  NULL);
  1934.     if (normalFont != NULL)
  1935.         XtSetValues(label,argList, 1);
  1936.     auth_toggle = XtVaCreateManagedWidget("authToggle",
  1937.                    commandWidgetClass,
  1938.                    connectpopup->form,
  1939.                    XtNlabel, (auth == TRUE) ? "enabled" : "disabled",
  1940.                    NULL);
  1941.     if (normalFont != NULL)
  1942.         XtSetValues(auth_toggle,argList, 1);
  1943.     XtAddCallback(auth_toggle, XtNcallback,    configToggle, &newauth);
  1944.  
  1945.     connectpopup->tuple[2].label = XtVaCreateManagedWidget("userLabel",
  1946.                             labelWidgetClass,
  1947.                             connectpopup->form,
  1948.                             NULL);
  1949.     if (normalFont != NULL)
  1950.         XtSetValues(connectpopup->tuple[2].label,argList, 1);
  1951. if (normalFont == NULL)
  1952.     connectpopup->tuple[2].text = XtVaCreateManagedWidget("userText",
  1953.                            asciiTextWidgetClass,
  1954.                            connectpopup->form,
  1955.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1956.                                   XtNresize, XawtextResizeWidth,
  1957.                            NULL);
  1958. else
  1959.     connectpopup->tuple[2].text = XtVaCreateManagedWidget("userText",
  1960.                            asciiTextWidgetClass,
  1961.                            connectpopup->form,
  1962.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1963.                                   XtNresize, XawtextResizeWidth,
  1964.               XtNfont,        normalFont,
  1965.                            NULL);
  1966.  
  1967.     connectpopup->tuple[3].label = XtVaCreateManagedWidget("passwdLabel",
  1968.                             labelWidgetClass,
  1969.                             connectpopup->form,
  1970.                             NULL);
  1971.     if (normalFont != NULL)
  1972.         XtSetValues(connectpopup->tuple[3].label,argList, 1);
  1973. if (normalFont == NULL)
  1974.     connectpopup->tuple[3].text = XtVaCreateManagedWidget("passwdText",
  1975.                            asciiTextWidgetClass,
  1976.                            connectpopup->form,
  1977.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1978.                                   XtNresize, XawtextResizeWidth,
  1979.                            NULL);
  1980. else
  1981.     connectpopup->tuple[3].text = XtVaCreateManagedWidget("passwdText",
  1982.                            asciiTextWidgetClass,
  1983.                            connectpopup->form,
  1984.                            XtNscrollVertical, XawtextScrollWhenNeeded,
  1985.                                   XtNresize, XawtextResizeWidth,
  1986.               XtNfont,        normalFont,
  1987.                            NULL);
  1988.     XtOverrideTranslations(connectpopup->tuple[3].text, passwdTranslations);
  1989.     XtInstallAllAccelerators(connectpopup->tuple[0].text, 
  1990.                  connectpopup->form);
  1991.     XtInstallAllAccelerators(connectpopup->tuple[1].text, 
  1992.                  connectpopup->form);
  1993.     XtInstallAllAccelerators(connectpopup->tuple[2].text, 
  1994.                  connectpopup->form);
  1995.     XtInstallAllAccelerators(connectpopup->tuple[3].text, 
  1996.                  connectpopup->form);
  1997. }
  1998.  
  1999. MapVolume(bool)
  2000. int    bool;
  2001. {
  2002.     XtSetMappedWhenManaged(total_volume_label, bool);
  2003.     XtSetMappedWhenManaged(total_number_label, bool);
  2004. }
  2005.  
  2006. MapButtons(bool)
  2007. int    bool;
  2008. {
  2009.     /* various buttons that need auth */
  2010.     XtSetMappedWhenManaged(qcontrol_command, bool);
  2011.  
  2012.     XtSetMappedWhenManaged(channel_stop, bool);
  2013.     XtSetMappedWhenManaged(channel_start, bool);
  2014.     XtSetMappedWhenManaged(channel_cacheadd, bool);
  2015.     XtSetMappedWhenManaged(channel_downforce, bool);
  2016.     XtSetMappedWhenManaged(channel_clear, bool);
  2017.  
  2018.     XtSetMappedWhenManaged(mta_stop, bool);
  2019.     XtSetMappedWhenManaged(mta_start, bool);
  2020.     XtSetMappedWhenManaged(mta_cacheadd, bool);
  2021.     XtSetMappedWhenManaged(mta_force, bool);
  2022.     XtSetMappedWhenManaged(mta_downforce, bool);
  2023.     XtSetMappedWhenManaged(mta_clear, bool);
  2024.  
  2025.     XtSetMappedWhenManaged(msg_stop, bool);
  2026.     XtSetMappedWhenManaged(msg_start, bool);
  2027.     XtSetMappedWhenManaged(msg_cacheadd, bool);
  2028.     XtSetMappedWhenManaged(msg_force, bool);
  2029.     XtSetMappedWhenManaged(msg_clear, bool);
  2030. }
  2031.